Method and apparatus for multiplication and/or modular reduction processing

ABSTRACT

The subject invention relates to a method and apparatus for multiplication of numbers. In a specific embodiment, the subject invention can be used to perform sequential multiplication. The subject invention also pertains to a method and apparatus for modular reduction processing of a number or product of two numbers. In a specific embodiment, sequential multiplication can be incorporated to perform modular reduction processing. The subject method and apparatus can also be utilized for modular exponentiation of large numbers. In a specific embodiment, numbers larger than or equal to 2 128  or even higher can be exponentiated. For example, the subject invention can be used for exponentiation of number as large as 2 1024 , 2 2048 , 2 4096 , or even larger.

CROSS-REFERENCE TO A RELATED APPLICATION

[0001] This application claims priority from provisional patent application U.S. Ser. No. 60/324,718; filed Sep. 24, 2001 and provisional patent application U.S. Ser. No. 60/274,893; filed Mar. 9, 2001.

BACKGROUND OF THE INVENTION

[0002] The subject invention relates to a method and apparatus for performing multiplication and/or modular reduction computations. The subject method and apparatus can utilize the Barrett modular reduction algorithm (see for example Menezes, A., van Oorschot, P., and Vanstone, S., Handbook of Applied Cryptography, CRC Press, 1996) to implement automatic computing machinery. The subject method and apparatus can be used to implement modular multiplication and exponentiation operations.

[0003] In the past, it has often been impractical to implement large-scale digital processors using a single semiconductor device due to the limitations of the amount of logic that can be placed on such a device. This has led to the selection and development of processors that are optimized for minimum silicon resource utilization. Modular reduction and modular multiplication has been implemented using the Montgomery reduction or Montgomery multiplication algorithms (see for example Menezes, et al.). Implementations using the Montgomery algorithms have the advantage of requiring less memory and fewer discreet multiplication operations than required to implement the Barrett algorithm. As it became possible to integrate large-scale digital processors onto a single semiconductor device, the methodology of using Montgomery algorithm implementations was carried forward. An example of such a digital processor is given in U.S. Pat. No. 6,085,210 (Buer). Other examples of Montgomery algorithm digital processors can be found in U.S. Pat. No. 6,240,436 (McGregor), U.S. Pat. No. 6,282,290 (Powell, et al.), and U.S. Pat. No. 6,185,596 (Hadad, et al.). These implementations suffer from limitations in the ability to exploit and sustain parallel use of many multipliers, thus limiting their overall processing speed.

[0004] The Barrett modular reduction algorithm is given here to establish notation (see for example Menezes, et al.).

[0005] Let x be a non-negative integer with up to a 2k digit radix b representation (x={x_(2k−1), . . . , x₁x₀}). Let m be a modulus with a k digit radix b representation where the most significant digit is not equal to zero (m={m_(k−1), . . . , m₁, m₀}, m_(k−1)≠0). The Barrett modular reduction algorithm computes r=x mod m, where rε{0, 1, 2, . . . , m−1}. Define μ=L└b^(2k)/m┘. The algorithm is given by the following steps.

[0006] 1. q₁←└x/b^(k−1)┘, q₂←q₁μ, q₃←└q₂/b^(k+1)┘

[0007] 2. r₁←x mod b^(k+1), r₂←q₃m mod b^(k+1), r←r₁−r₂

[0008] 3. If r<0 then r←r+b^(k+1)

[0009] 4. While r≧m do: r←r−m

[0010] Note that it is well-known that step 4 in the above algorithm will repeat not more than twice.

[0011] For an implementation of the Barrett algorithm using digital logic it is preferable to choose the radix b to be a power of two (e.g., b=2 ³²). Given the radix is a power of two, define N to be the number of bits per radix b digit; that is, N=log₂ b. It should be noted that if b is a power of two then the operator └•/b^(k)┘ is a right shift by k N-bit digits, and the operator (• mod b^(k)) is the k least significant N-bit digits.

BRIEF SUMMARY OF INVENTION

[0012] The subject invention relates to a method and apparatus for multiplication of numbers. In a specific embodiment, the subject invention can be used to perform sequential multiplication. The subject invention also pertains to a method and apparatus for modular reduction processing of a number or product of two numbers. In a specific embodiment, sequential multiplication can be incorporated to perform modular reduction processing. The subject method and apparatus can also be utilized for modular exponentiation of large numbers. In a specific embodiment, numbers larger than or equal to 2¹²⁸ or even higher can be exponentiated. For example, the subject invention can be used for exponentiation of number as large as 2¹⁰²⁴, 2²⁰⁴⁸, 2⁴⁰⁹⁶, or even larger.

BRIEF DESCRIPTION OF THE DRAWINGS

[0013]FIG. 1 shows a block diagram of a sequential modular reduction processor in accordance with the subject invention.

[0014]FIG. 2A shows a specific embodiment of a sequential adder in accordance with the subject invention.

[0015]FIG. 2B shows a specific embodiment of a sequential subtractor in accordance with the subject invention.

[0016]FIG. 2C shows a specific embodiment of a combined sequential adder/subtractor in accordance with the subject invention.

[0017]FIG. 3, shows a block diagram of a specific embodiment of a sequential multiplier in accordance with the subject invention.

[0018]FIG. 4 shows a block diagram of a specific embodiment of a sequential modular reduction processor in accordance with the subject invention.

[0019]FIG. 5 shows a block diagram of a specific embodiment of a sequential multiplier in accordance with the subject invention.

[0020]FIG. 6 shows a timing diagram illustrating the operation of a specific embodiment of a sequential multiplier in accordance with the subject invention.

[0021]FIG. 7A shows a specific embodiment of a sequential adder with operand multiplication by two in accordance with the subject invention.

[0022]FIG. 7B shows a specific embodiment of a sequential subtractor with operand multiplication by two in accordance with the subject invention.

[0023]FIG. 7C shows a specific embodiment of a combined sequential adder/subtractor with operand multiplication by two in accordance with the subject invention.

[0024]FIG. 8 shows a block diagram of a specific embodiment of a sequential modular reduction processor in accordance with the subject invention.

[0025]FIG. 9 shows a block diagram of a specific embodiment of a sequential modular reduction processor in accordance with the subject invention.

[0026]FIG. 10 shows a block diagram of a modular multiplier in accordance with the subject invention.

DETAILED DESCRIPTION OF THE INVENTION

[0027] The subject invention relates to a method and apparatus for multiplication of numbers. In w a specific embodiment, the subject invention can be used to perform sequential multiplication. The subject invention also pertains to a method and apparatus for modular reduction processing of a number or product of two numbers. In a specific embodiment, sequential multiplication can be incorporated to perform modular reduction processing. The subject method and apparatus can also be utilized for modular exponentiation of large numbers. In a specific embodiment, numbers larger than or equal to 2¹²⁸ or even higher can be exponentiated. For example, the subject invention can be used for exponentiation of number as large as 2¹⁰²⁴, 2²⁰⁴⁸, 2⁴⁰⁹⁶, or even larger.

[0028] A block diagram of a specific embodiment of a sequential modular reduction processor, using the notation described above, is shown in FIG. 1. The sequential modular reduction processor can perform processing one radix b digit at a time, starting with the least significant digit, and proceeding to the most significant digit. The input x can be supplied to the machine starting with the least significant digit. Alternatively, x can be received most significant digit first, stored, and processed least significant digit first. The entire stream of digits can be represented as the sequence {x_(i)|i=0, 1, 2, . . . , 2k−1}. A shift-and-truncate-down operator 1 produces the result q₁. Other means of dividing by b^(k−1) can also be used. Starting with the least significant digit of the result produced by the shift-and-truncate-down operator 1, a sequential multiplier 2 multiplies q₁ by μ producing q₂. The result of the sequential multiplier 2 is processed by another shift-and-truncate-down operator 3 to produce the result q₃. Again, other means of dividing by b^(k−1) can also be used. It is important to note that while this discussion specifies a sequential multiplier that accepts a stream of operand digits sequentially, and produces a stream of result digits sequentially, it is conceivable that in some instances all digits of the operands could be processed simultaneously by a multiplier. In practice, a direct multiplier implementation is challenging to construct efficiently in the neighborhood of 32-64 bit operands, becomes difficult in the neighborhood of 64-128 bit operands, and is very difficult to construct an efficient implementation of a direct multiplier for greater than 128 bit operands. The result q₃ is multiplied by m by a sequential multiplier 4 and modularly reduced by a modular reduction operator 5. The modular reduction operator 5 simply keeps the k+1 least significant digits of the product produced by the sequential multiplier 4.

[0029] Meanwhile, the input x is also reduced by a modular reduction operator 6. The result of the modular reduction operator 5 is subtracted from the result of the modular reduction operator 6 by a sequential subtraction operator 7. Steps 3 and 4 can implemented in a variety of ways to determine a final result for x mod m, where x mod m ε{0, 1, 2, . . . , m−1}. Including the difference r produced by the sequential subtraction operator 7, which corresponds to step 2 in the modular reduction algorithm described above, six different candidate final results can be computed in order to provide the values that may be produced by steps 3 and 4 in the algorithm. In a specific embodiment, sequential arithmetic operators can be used such that the direction of the branches are not known until the most significant (and last) digit is processed. A sequential addition operator 8 can implement the addition implied by step 3 of the algorithm. A sequential subtraction operator 9 followed by another sequential sequential subtraction operator 10 can produce the two possible values implied by step 4 of the algorithm if r<0 in step 3. Simultaneously, a sequential subtraction operator 11 followed by another sequential subtraction operator 12 can produce the two possible values implied by step 4 of the algorithm if r≧0 in step 3. Selection of the final result can be accomplished when the last digit is processed by the sequential subtraction operators 7, and 9-12.

[0030] Since the sequential modular reduction processor shown in FIG. 1 is a feed-forward system, pipelining may be added at the user's discretion to achieve higher throughput. Operator scheduling or sharing may also be implemented to reduce the amount of hardware required to implement the processor shown in FIG. 1. Specifically, the sequential multipliers 2 and 4 may be implemented using a single sequential multiplier implementation, and the six sequential addition/subtraction operators 7-12 may be implemented using fewer than six sequential addition/subtraction implementations.

[0031] Referring to FIG. 4, a block diagram of a specific embodiment of the subject invention is shown. FIG. 4 shows a sequential modular reduction processor in which the differences produced by the sequential subtraction operators 7, 9, and 10, can be represented as two's complement values. Referring back to FIG. 1, if the difference produced by the sequential subtraction operator 7 is negative, then the sum produced by the sequential add operator 8 will be zero in the k+1'th word, and first through k'th word produced by the sequential add operator 8 will be the same as the output of the sequential subtraction operator 7 in those words. It is also the case that if the difference produced by the sequential subtraction operator 7 is positive, then the output of the operator 7 will also be zero in the k+1'th word. This implies that the operator 8 can be realized by blanking the k+1'th word of the output of the operator 7 and that the input to the sequential subtraction operators 9 and 11 will be exactly the same up to the selection of the correct result from {r, r_(p), r_(pa1), r_(pa2), r_(a1), r_(a2)}. Therefore, the sequential subtraction operators 11 and 12 are redundant, and the results {r_(p), r_(pa1), r_(pa2)} do not have to be stored pursuant to selection of the correct result by means of the algorithm described above. This is significant as it reduces the number of speculatively stored results from six to three. The embodiment shown in FIG. 4 is effected by removing operators 11 and 12 from the embodiment of FIG. 1, and replacing the operator 8 shown in FIG. 1 with an operator 13 that forces the k+1'th word of each operation to zero.

[0032] Referring to FIG. 8, a block diagram of a specific embodiment of the subject invention is shown. Referring back to FIG. 1, sequential subtraction operators 9 and 10 produce the differences r_(pa1)=r_(p)−m and r_(pa2)=r_(pa1)−m, while sequential subtraction operators 11 and 12 produce the differences r_(a1)=r−m and r_(a2)=r_(a1)−m. Alternatively, the differences r_(pa2) and r_(a2) may be produced as r_(pa2)=r_(p)−2m and r_(a2)=r−2m, as is demonstrated in FIG. 8. The former difference is computed by a sequential subtractor with multiplication of the subtrahend input by two, 41, while the latter difference is computed by a sequential subtractor with multiplication of the subtrahend input by two, 42. This is significant as the differences r_(pa1), r_(pa2), r_(a1), and r_(a2) are produced simultaneously, making all of these results available one clock cycle sooner than they would be otherwise.

[0033] Referring to FIG. 9, a block diagram of a specific embodiment of the subject invention is shown. Referring back to FIG. 4, sequential subtraction operators 9 and 10 produce the differences r_(pa1)=r_(p)−m and r_(pa2)=r_(pa1)−m. Alternatively, the difference r_(pa2) may be produced as r_(pa2)=r_(p)−2m, as is demonstrated in FIG. 9. This difference is computed by a sequential subtractor with multiplication of the subtrahend input by two, 41. This is significant as the differences r_(pa1) and r_(pa2) are produced simultaneously, making these results available one clock cycle sooner than they would be otherwise.

[0034] Since the sequential modular reduction processors shown in FIGS. 4, 8, and 9 are feed-forward systems, pipelining may be added at the user's discretion to achieve higher throughput. Operator scheduling or sharing may also be implemented to reduce the amount of hardware required to implement the processor shown in FIG. 1. Specifically, the sequential multipliers 2 and 4 may be implemented using a single sequential multiplier implementation, and the w sequential addition/subtraction operators 7-11, 41, and 42 may be implemented using fewer sequential adders/subtractors with and without operand multiplication by two implementations than are shown in FIGS. 4, 8, and 9.

[0035] A block diagram of a sequential adder, sequential subtractor, and combined sequential adder and subtractor is shown in FIGS. 2A, 2B, and 2C, respectively. The sequential adder shown in FIG. 2A uses an N-bit binary adder 21 with a carry input and carry output to compute y_(i)=a_(i)+b_(i). The carry input is supplied by a register 22 that receives its input from a multiplexer 23. To start a sequential addition operation, the rst signal is asserted for one cycle, setting the value stored in the register 22 to 0, and causing the carry in of the adder 21 to be 0. After the rst signal is negated, the sequences of operands {a_(i)|i=0, 1, 2, . . . , k−1} and {b_(i)|i=0, 1, 2, . . . , k−1} are presented to the inputs of the adder 21 at the rate of one per clock cycle to produce the sum y_(i).

[0036] The sequential subtractor shown in FIG. 2B is used to compute the difference y_(i)=a_(i)−b_(i). The operation of the sequential subtractor is essentially the same as the sequential adder in FIG. 2A, except the operand b_(i) is negated by the inverters 24, and when rst is asserted, the carry-input register is set to 1.

[0037] The combined sequential adder/subtractor shown in FIG. 2C may be used to compute the sum y_(i)=a_(i)+b_(i) or the difference y_(i)=a_(i)−b_(i). This structure is similar to the structures presented in FIG. 2A and FIG. 2B, except the operand b_(i) is negated using an exclusive-or operation 25 if and only if mode is asserted. Additionally, when rst is asserted, the carry input register samples mode: for an addition operation, mode will be 0, while for a subtraction operation mode will be 1.

[0038] A block diagram of a sequential adder with multiplication of one operand by two, a sequential subtractor with multiplication of one operand by two, and a combined sequential adder and subtractor with multiplication of one operand by two is shown in FIGS. 7A, 7B, and 7C, respectively. The sequential adder with multiplication of one operand by two shown in FIG. 7A uses an N-bit binary adder 21 with a carry input and carry output to compute y_(i)=a_(i)+2b_(i). The operand b_(i) is multiplied by two by shifting one bit left, saving the most significant bit (MSB) in a register 22 for the next cycle, and taking the MSB from the previous cycle, which is stored in the register 22 and making it the LSB for the current cycle. The carry input is supplied by a register 22 that receives its input from a multiplexer 23. To start a sequential addition operation, the rst signal is asserted for one cycle, setting the values stored in the carry-in register 22 and the shift register 22 to 0, and causing the carry in of the adder 21 to be 0. After the rst signal is negated, the sequences of operands {a_(i)|i=0, 1, 2, . . . , k−1} and {b_(i)|i=0, 1, 2, . . . , k−1} are presented to the inputs of the adder 21 at the rate of one per clock cycle to produce the sum y_(i).

[0039] The sequential subtractor with multiplication of one operand by two shown in FIG. 7B is used to compute the difference y_(i)=a_(i)−2b_(i). The operation of the sequential subtractor with multiplication of one operand by two is essentially the same as the sequential adder with multiplication of one operand by two in FIG. 7A, except the value 2b_(i) is negated by the inverters 24, and when rst is asserted, the carry-input register is set to 1.

[0040] The combined sequential adder/subtractor with multiplication of one operand by two shown in FIG. 7C may be used to compute the sum y₁=a_(i)+2b_(i). or the difference y_(i)=a_(i)−2b_(i). This structure is similar to the structures presented in FIG. 7A and FIG. 7B, except the value 2b_(i). is negated using an exclusive-or operation 25 if and only if mode is asserted. Additionally, when rst is asserted, the carry input register samples mode: for an addition operation, mode will be 0, while for a subtraction operation mode will be 1.

[0041] Implementation of sequential multiplication depends upon the use of a polynomial decomposition of the operands and sequential processing of the decomposed operands. Using the notation described above, let a and c have k digit radix b decompositions {a_(i)|i=0, 1, 2, . . . , k−1} and {c_(i)|i=0, 1, 2, . . . , k−1}. Then y=ac has a 2k digit radix b decomposition {y′_(i)|i=0, 1, 2, . . . , 2k−1}. This can be produced by producing the sequence {y′_(i)|i=0, 1, 2, . . . , 2k−2}, where y′_(i)=Σ_(j=0) ^(i)a_(j)c_(i−j), which is seen to be linear convolution, and accumulating these results by forming the sum y=Σ_(i=0) ^(2k−2)y′_(i)b^(i), wherein {y_(i)|i=0, 1, 2, . . . , 2k−1}. In the preferred embodiment b=2^(N), so the term y′_(i)b^(i) can be produced by shifting the term y′_(i) left iN bit positions.

[0042] A block diagram of a sequential multiplier is shown in FIG. 3. In this implementation, a register file 33 stores the operands corresponding to b_(i), while a shift register 34 stores operands corresponding to a_(i). The operation of the register file 33 is controlled by separate enables for each register, (en0, en1, . . . , enk−1). The en0 enable is asserted for the first data input, the en1 is asserted for the second input, and so forth. When en0 is asserted for the first input, a multiplexer 31 causes 0 to be broadcast to all of the remaining registers in the register file. The registers in the register file 33 controlled by en1, en2, . . . , enk−1, have their enables logically ORed with en0 by a plurality of OR gates 32. The a_(i) inputs are shifted into the shift register 34 at the same time that the corresponding inputs b_(i) are written into the register file. After the a_(i) inputs are exhausted, zeros are shifted into the shift register 34 until the computation is completed. The products of the operands in the register file 33 and the shift register 34 are computed by a plurality of multipliers 35, and the sum of these products is computed by a multi-port adder 36. This sum of products is added to the carry from the previous sum of products by an adder 38, where the carry from the previous sum of products was stored in the previous cycle in a register 37. The carry feedback register 37 must be reset using the rst input before computation begins. For 2k−1 cycles, the output of the sequential multiplier is selected to be the output of the adder 38 by a multiplexer 39. On the last cycle of multiplication, the last signal is asserted, and the final output is selected from the carry feedback register 37 by the multiplexer 39.

[0043] In order to use the embodiment shown in FIG. 3 to directly compute a product of the two operands with decompositions {a_(i)|i=0, 1, 2, . . . , p−1} and {b_(i)|i=0, 1, 2, . . . , p−1}, where p is the greatest integer such that a_(i)≠0 or b_(i)≠0, it is necessary that k≧p. If p>k then the sequential multiplier shown in FIG. 3 may be profitably exploited to compute the product of the operands by applying a block multiplication algorithm using the embodiment shown in FIG. 3 as an operator in that implementation.

[0044] The sequential multiplier may be implemented using either conventional arithmetic technologies, or a more favorable implementation may be realized using RNS as suggested by the author in patent application U.S. Ser. No. 09/569,944, filed May 12, 2000, which is incorporated herein by reference.

[0045] The sequential multiplier shown in FIG. 3 multiplies two k digit radix b values to produce a 2k digit product. Use of this architecture implies that many of the products computed by the multiplication operators 35 will be multiplication by zero (producing zero). As multiplication by zero is a trivial operation compared to a general multiplication operation, it is possible to modify the architecture shown in FIG. 3 by using two sets of operators 36, 37, 38, and 39, in addition to other elements and modifications, to double the throughput of the multiplier, as for example in the embodiment illustrated in FIG. 5.

[0046] The major differences between the sequential multiplier shown in FIG. 3 and the sequential multiplier shown in FIG. 5 are the following. The method for resetting the register file 33, comprising the multiplexor 31 and the OR operators 32 in FIG. 3 are not required in the sequential multiplier shown in FIG. 5. The duplicated sets of operators 36, 37, 38, and 39, are connected to the multipliers via a plurality of zero multiplexors 40. When the a_(i) operands for a particular operation are exhausted, it is not necessary to shift zeros in to complete the operation. Instead, assertion and negation of the ena0, . . . , enak−1 and enb0, . . . , enbk−1 signals controls which multiplication operator 35 locations are providing zero, using the zero multiplexors 40, to the partial sum of products accumulators comprising operators 36, 37, 38, and 39.

[0047] The operation of the sequential multiplier shown in FIG. 5 is illustrated by example using the timing diagram shown in FIG. 6. For purposes of the example a four multiplier architecture is used, but the example is easily expanded to smaller or larger operations and architectures.

[0048] In order to use the embodiment shown in FIG. 5 to directly compute a product of the two operands with decompositions {a_(i)|i=0, 1, 2, . . . , p−1} and {b_(i)|i=0, 1, 2, . . . , p−1}, where p is the greatest integer such that a_(i)≠0 or b_(i)≠0, it is necessary that k≧p. If p>k then the sequential multiplier shown in FIG. 5 may be profitably exploited to compute the product of the operands by applying a block multiplication algorithm using the embodiment shown in FIG. 5 as an operator in that implementation.

[0049] A block diagram of a modular multiplier is shown in FIG. 10. The modular multiplier comprises a sequential multiplier 43, that accepts two operand sequences {a_(i)|i=0, 1, 2, . . . , k−1} and {b_(i)|i=0, 1, 2, . . . , k−1}, and sequentially produces the produce sequence {x_(i) |i=0, 1, 2, . . . , 2k−1}. The 2k digit product produced by the sequential multiplier is input to a modular reduction processor 44, which is an embodiment of one of the implementations shown in FIGS. 1, 4, 8, and 9. The operands m and μ must also be input to the modular reduction processor. The modular reduction processor, depending upon the specific embodiment selected for implementation, will sequentially produce either three or six candidate results that are stored in a memory 45. Upon completion of the calculation the correct result is selected from the memory according to the criteria of the Barrett modular reduction algorithm.

[0050] All patents, patent applications, provisional applications, and publications referred to or cited herein are incorporated by reference in their entirety to the extent they are not inconsistent with the explicit teachings of this specification.

[0051] It should be understood that the examples and embodiments described herein are for illustrative purposes only and that various modifications or changes in light thereof will be suggested to persons skilled in the art and are to be included within the spirit and purview of this application and the scope of the appended claims. 

1. A method of modular reduction processing of a number which is represented by a sequence of digits, comprising: receiving a number x, wherein number x is provided in radix b form and is represented by sequence of 2k digits such that {x_(i)|i=0, 1, 2, . . . , 2k−1}; dividing x by b^(k+1) to produce q₁; multiplying q₁ by μ to produce q₂, wherein μ is given in radix b form and is represented by sequence of k+1 digits such that μ=└b^(2k)/m┘, wherein m is modulus given in radix b form and is represented by sequence of k digits such that {m_(i)|i=0,1, 2, . . . , 2k−1} wherein m_(k−1)≠0); dividing q₂ by b^(k+1) to produce q₃; multiplying q₃ by m; reducing the product of q₃ multiplied by m modulo b^(k+1) to produce r₂; reducing x modulo b^(k+1) to produce r₁; subtracting r₂ from r₁ to produce r; and determining which of the following is true: r is non-negative and r_(a1) is negative, wherein r_(a1) is r−m; r is non-negative and r_(a1) is non-negative and r_(a2) is negative, wherein r_(a2) is r−2m; r is non-negative and r_(a2) is non-negative; r is negative and r_(pa1) is negative, wherein r_(pa1)=r+b^(k+1)−m; r is negative and r_(pa1) is non-negative and r_(pa2) is negative, wherein r_(pa2)=r+b^(k+1)−2m; and r is negative and r_(pa2) is non-negative, wherein if r is non-negative and r_(a1) is negative, x mod m=r, wherein if r is non-negative and r_(a1) is non-negative and r_(a2) is negative, x mod m=r−m, wherein if r is non-negative and r_(a2) is non-negative, x mod m=r−2m, wherein if r is negative and r_(pa1) is negative, x mod m=r+b^(k+1), wherein if r is negative and r_(pa1) is non-negative and r_(pa2) is negative, x mod m=r+b^(k+1)−m, and wherein if r is negative and r_(pa2) is non-negative, x mod m=r+b^(k+1)−2m.
 2. The method according to claim 1, wherein x is received least significant digit first and in digits in increasing order of significance thereafter.
 3. The method according to claim 1, wherein b is a power of
 2. 4. The method according to claim 3, wherein dividing x by b^(k−1) comprise removing the k−1 least significant digits from x.
 5. The method according to claim 1, wherein reducing the product of q₃ multiplied by m modulo b^(k+1) to produce r₂ comprises taking the k+1 least significant digits of q₃m mod b^(k+1).
 6. The method according to claim 1, wherein subtracting r₂ from r₁ to produce r comprises sequentially subtracting r₂ from r₁ to produce r.
 7. A method of sequential multiplication for multiplying two numbers, each number having no more than kN bits, comprising: a. receiving a first number a, wherein a is represented by a sequence of k digits such that {a_(i)|i=0, 1, 2, . . . , k−1} and each as is a radix b digit having N bits; b. receiving a second number c, wherein c is represented by a sequence of k digits such that {c_(i)|i=0, 1, 2, . . . , k−1} and each c_(i) is a radix b digit having N bit; c. producing a sum y=Σ_(i=0) ^(2k−2)y′_(i)b^(i), wherein y′_(i)=Σ_(j=0) ^(i)a_(j)c_(i−j), such that y′_(i) can be represented as a sequence of 2k−1 digits such that {y′_(i)|i=0, 1, 2, . . . , 2k−2}, wherein y is the product of a and c and can be represented by a sequence of 2k digits such that {y_(i)|i=0, 1, 2, . . . , 2k−1} and each y₁ is a radix b digit having N bits.
 8. The method according to claim 7, wherein producing the sum y comprises: a. inputting a least significant digit of a into a first register of a shift register; b. inputting a least significant digit of c into first register of a register file and setting the remaining registers of the register file to zero; c. multiplying a value of each register of the shift register by a value of a corresponding register of the register file and adding the products to produce a first sum; d. selecting the least significant N bits of the first sum as the least significant N bits of a product of a and c; e. selecting the most significant N+└log2k┘=1 bits of the first sum and saving the most significant N+└log2k┘+1 bits of the first sum in a carry register; f. inputting the next least significant digit of a into the first register of the shift register and shifting the shift register values; g. inputting the next least significant digit of c into the next register of the register file; h. multiplying the value of each register of the shift register by the value of a corresponding register of the register file and adding the products to produce a next first sum; i. adding the first sum to the value of the carry register to produce a second sum; j. selecting the least significant N bits of the second sum as the next least significant N bits of a product of a and c; k. selecting the most significant N+└log2k┘=1 bits of the second sum and saving the most significant N+└log2k┘+1 bits of the second sum in the carry register; l. inputting the next least significant digit of a into the first register of the shift register and shifting the shift register values; m. inputting the next least significant digit of c into the next register of the register file; n. multiplying the value of each register of the shift register by the value of the corresponding register of the register file and adding the products to produce a next first sum; o. adding the next first sum to the value of the carry register to produce a next second sum; p. selecting the least significant N bits of the next second sum as the next least significant N bits of the product of a and c; q. selecting the most significant N+└log2k┘+1 bits of the next second sum and saving the most significant N+└log2k┘+1 bits of the next second sum in the carry register; r. repeating steps j through o k−3 times; s. inputting a zero into the first register of the shift register and shifting the shift register values; t. multiplying the value of each register of the shift register by the value of the corresponding register file and adding the products to produce a next first sum; u. adding the next first sum to the value of the carry register to produce a next second sum; v. selecting the least significant N bits of the next second sum as the next least significant N bits of the product of a and c; w. selecting the most significant N+└log2k┘+1 bits of the next second sum in the carry register; x. repeating steps s through w k−1 times; and y. selecting the value in the carry register as the most significant N bits of the product of a and c.
 9. A method of modular reduction processing of a product of two numbers, comprising: receiving a first number a, wherein a is provided in radix b form and is represented by a sequence of k digits such that {a_(i) |i=0, 1, 2, . . . , k−1}; receiving a second number c, wherein c is provided in radix b form and is represented by a sequence of k digits such that {c_(i)|i=0, 1, 2, . . . , k−1}; multiplying the first number and the second number to produce a product which is represented by a sequence of 2k digits; inputting the product into a modular reduction processor, wherein the modular reduction processor outputs one or more of the following: r, r−m, r−2m, r+b^(k+1), r+b^(k+1)−m, and r+b^(k+1)−2m, wherein r=x mod b^(k+1)−m[[μ(x/b^(k−1))]/b^(k+1)] mod b^(k+1), into a means for determining which of the following is true: r is non-negative and r_(a1) is negative, wherein r_(a1) is r−m; r is non-negative and r_(a1) is non-negative and r_(a2) is negative, wherein r_(a2) is r−2m; r is non-negative and r_(a2) is non-negative; r is negative and r_(pa1) is negative, wherein r_(pa1)=r+b^(k+1)−m; r is negative and r_(pa1) is non-negative and r_(pa2) is negative, wherein r_(pa2)=r+b^(k+1)−2m; and r is negative and r_(pa2) is non-negative, wherein if r is non-negative and r_(a1) is negative, x mod m=r, wherein if r is non-negative and r_(a1) is non-negative and r_(a2) is negative, x mod m=r−m, wherein if r is non-negative and r_(a2) is non-negative, x mod m=r−2m, wherein if r is negative and r_(pa1) is negative, x mod m=r+b^(k+1), wherein if r is negative and r_(pa1) is non-negative and r_(pa2) is negative, x mod m=r+b^(k+1)−m, and wherein if r is negative and r_(pa2) is non-negative, x mod m=r+b^(k+1)−2m. 